home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / glammar / ge40.c < prev    next >
C/C++ Source or Header  |  1991-01-21  |  20KB  |  1,041 lines
  1. /*
  2.  
  3.     This file is a part of the GLAMMAR source distribution 
  4.     and therefore subjected to the copy notice below. 
  5.     
  6.     Copyright (C) 1989,1990  Eric Voss, ericv@cs.kun.nl 
  7.  
  8.     This program is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation version 1
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21. /*
  22.  * file: mp.c last modified: Fri May 18 09:57:36 MET DST 1990
  23.  *
  24.  */
  25.  
  26. #include <mp.h>
  27. #include <stdio.h>
  28. #include <ctype.h>
  29.  
  30. #define true 1
  31. #define false 0
  32.  
  33. MINT * dectoint ();
  34.  
  35. #define MAX_SHORT 32767
  36. #define MIN_SHORT -32768
  37.  
  38. typedef struct affix_struct {
  39.   char           *t;
  40.   struct affix_struct  *l, *r;
  41. } affix,*AFFIX;
  42.  
  43. extern AFFIX first_meta,last_meta; 
  44.  
  45. typedef union {
  46.   void             (*q) ();
  47.   int           *i;
  48.   char           *s;
  49.   char          **l;
  50.   AFFIX   a;
  51. }               cont;
  52.  
  53.  
  54. extern cont     words[],*q_top;
  55. extern char    *input;
  56. extern char    *cstore,*cstore_top;
  57.  
  58. extern cont    *q;
  59. extern char *fast_list_acces;
  60. extern char    *ip, *mip, *set_ip_start_pos, *limitip, *undefined, *empty, *c;
  61.  
  62. extern int      rcount, rmax, set_ip_start_num, cssize;
  63. extern int      parsecount, nrofchars, level, eval_count, 
  64.                 interesting_level_number, backtrace;
  65. extern char     in_file_name[256], out_file_name[256], current_file_name[256];
  66. extern char    *thischar;
  67. extern FILE    *inputfile,*output;
  68. extern int             set_line_num;
  69. extern char            *set_line_pos;
  70. extern char            *set_file_name ;
  71. extern char            *inputbuff;
  72. extern int             change_line_file;
  73.  
  74.  
  75. extern char *argv[11];
  76.  
  77. extern affix *af;
  78.  
  79. #define nil NULL
  80. #define ASSIGN(x,tr,lf,rt) (*(x)).t = tr ;(*(x)).l = lf;(*(x)).r = rt
  81. #define COPY(x,y) (x)->t = (y)->t ; (x)->l = (y)->l ; (x)->r = (y)->r
  82. #define SAVE(x,y) x.t = (y)->t ; x.l = (y)->l ; x.r = (y)->r
  83. #define RESTORE(x,y) (x)->t = y.t;  (x)->l = y.l;  (x)->r = y.r
  84. #define SHARE(x,y) (x)->t = empty ; (x)->l = nil ; (x)->r = y
  85. #define MAKE(x,y) if ( (y)->t == undefined) { SHARE(x,y);} else { COPY (x,y); }
  86. #define CONTINUE  q -=1;(*(*(q+1)).q)()
  87.  
  88.  
  89.  
  90. #define GET_MINT_ADDR(mint,str)\
  91. { register char *d = (char *) & mint;\
  92.    register char *rc = str; \
  93.    if ( (rc[0] == '\002') && (rc[5] == '\002') && (rc[6] == '\000')) {\
  94.    d [0] = rc [1] ; d[1] = rc [2]; d [2] = rc [3];\
  95.       d[3] = rc[4];\
  96.    } else mint = (MINT *) -1;\
  97. }
  98.                                 
  99.  
  100. #define PUT_MINT_ADDR(mint)\
  101.  { register unsigned long d = (unsigned long)  mint;\
  102.    register char *rc = c; rc[0] = '\002' ; rc[1] = (char) (d >>24);\
  103.    rc [2] = (char) (d>>16); rc [3] = (char) (d >>8); rc [4] = (char) d ;\
  104.    rc [5] = '\002'; rc [6] = '\0'; c = rc+7;} 
  105.                                 
  106.  
  107.  
  108. #ifdef DMP
  109.  
  110. short szero = 0;
  111. MINT mzero_ = {1,&szero};
  112. MINT *mzero = &mzero_;
  113.  
  114. /*  intplusintisint   */
  115. int dintplusintisint(A,B,C)
  116. register AFFIX A;
  117. register AFFIX B;
  118. register AFFIX C;
  119. {
  120.   char           *xs = c, *csave = c;
  121.   MINT   *m1,*m2,*m3;
  122.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  123.   else {
  124.     sprinta(A);
  125.     *c++ = '\0';
  126.   }
  127.   GET_MINT_ADDR(m1,xs);
  128.   if ( (int) m1 == -1)  return false;
  129.   c = csave;
  130.   if ((B->r == nil) && (B->l == nil)) xs = B->t;
  131.   else {
  132.     sprinta(B);
  133.     *c++ = '\0';
  134.   }
  135.   GET_MINT_ADDR(m2,xs);
  136.   if ( (int) m2 == -1)  return false;
  137.   c = csave;
  138.   m3 = itom(0);
  139.   madd (m1,m2,m3);
  140.   C->t = c;
  141.   C->l = nil;
  142.   C->r = nil;
  143.   PUT_MINT_ADDR(m3);
  144.   return true;
  145.  
  146. }
  147.  
  148. /*  intsubintisint   */
  149. int dintsubintisint(A,B,C)
  150. register AFFIX A;
  151. register AFFIX B;
  152. register AFFIX C;
  153. {
  154.   char           *xs = c, *csave = c;
  155.   MINT   *m1,*m2,*m3;
  156.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  157.   else {
  158.     sprinta(A);
  159.     *c++ = '\0';
  160.   }
  161.   GET_MINT_ADDR(m1,xs);
  162.   if ( (int) m1 == -1)  return false;
  163.   c = csave;
  164.   if ((B->r == nil) && (B->l == nil)) xs = B->t;
  165.   else {
  166.     sprinta(B);
  167.     *c++ = '\0';
  168.   }
  169.  
  170.   GET_MINT_ADDR(m2,xs);
  171.   if ( (int) m2 == -1)  return false;
  172.   c = csave;
  173.   m3 = itom(0);
  174.   msub (m1,m2,m3);
  175.   C->t = c;
  176.   C->l = nil;
  177.   C->r = nil;
  178.   PUT_MINT_ADDR(m3);
  179.   return true;
  180.  
  181. }
  182.  
  183.  
  184.  
  185. /*  inttimesintisint   */
  186. int dinttimesintisint(A,B,C)
  187. register AFFIX A;
  188. register AFFIX B;
  189. register AFFIX C;
  190. {
  191.   char           *xs = c, *csave = c;
  192.   MINT   *m1,*m2,*m3;
  193.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  194.   else {
  195.     sprinta(A);
  196.     *c++ = '\0';
  197.   }
  198.   GET_MINT_ADDR(m1,xs);
  199.   if ( (int) m1 == -1)  return false;
  200.   c = csave;
  201.   if ((B->r == nil) && (B->l == nil)) xs = B->t;
  202.   else {
  203.     sprinta(B);
  204.     *c++ = '\0';
  205.   }
  206.   GET_MINT_ADDR(m2,xs);
  207.   if ( (int) m2 == -1)  return false;
  208.   c = csave;
  209.   m3 = itom(0);
  210.   mult (m1,m2,m3);
  211.   C->t = c;
  212.   C->l = nil;
  213.   C->r = nil;
  214.   PUT_MINT_ADDR(m3);
  215.   return true;
  216.  
  217. }
  218.  
  219.  
  220. /*  intdividedbyintisintwithremainderint   */
  221. int dintdividedbyintisintwithremainderint(A,B,C,D)
  222. register AFFIX A;
  223. register AFFIX B;
  224. register AFFIX C;
  225. register AFFIX D;
  226. {
  227.   char           *xs = c, *csave = c;
  228.   MINT   *m1,*m2,*m3,*m4;
  229.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  230.   else {
  231.     sprinta(A);
  232.     *c++ = '\0';
  233.   }
  234.   GET_MINT_ADDR(m1,xs);
  235.   if ( (int) m1 == -1)  return false;
  236.   c = csave;
  237.   if ((B->r == nil) && (B->l == nil)) xs = B->t;
  238.   else {
  239.     sprinta(B);
  240.     *c++ = '\0';
  241.   }
  242.   GET_MINT_ADDR(m2,xs);
  243.   if ( (int) m2 == -1)  return false;
  244.   c = csave;
  245.   m3 = itom(0);
  246.   m4 = itom(0);
  247.   mdiv (m1,m2,m3,m4);
  248.   C->t = c;
  249.   C->l = nil;
  250.   C->r = nil;
  251.   PUT_MINT_ADDR(m3);
  252.   D->t = c;
  253.   D->l = nil;
  254.   D->r = nil;
  255.   PUT_MINT_ADDR(m4);
  256.   return true;
  257. }
  258.  
  259.  
  260. /*  intisint   */
  261. int dintisint(A,B,C)
  262. register AFFIX A;
  263. register AFFIX B;
  264. register AFFIX C;
  265. {
  266.   char           *xs = c, *csave = c;
  267.   MINT   *m1,*m2;
  268.   int i;
  269.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  270.   else {
  271.     sprinta(A);
  272.     *c++ = '\0';
  273.   }
  274.   GET_MINT_ADDR(m1,xs);
  275.   if ( (int) m1 == -1)  return false;
  276.   c = csave;
  277.   if ((C->r == nil) && (C->l == nil)) xs = C->t;
  278.   else {
  279.     sprinta(C);
  280.     *c++ = '\0';
  281.   }
  282.   GET_MINT_ADDR(m2,xs);
  283.   if ( (int) m2 == -1)  return false;
  284.   c = csave;
  285.   i = mcmp (m1,m2);
  286.   if (i == 0)
  287.      B->t = "0";
  288.   else if (i < 0)
  289.      B->t = "-1";
  290.   else 
  291.      B->t = "1";
  292.   B->l = nil;
  293.   B->r = nil;
  294.   return true;
  295.  
  296. }
  297.  
  298. /*  intraisedbyintmodulointisint   */
  299. int dintraisedbyintmodulointisint(A,B,C,D)
  300. register AFFIX A;
  301. register AFFIX B;
  302. register AFFIX C;
  303. register AFFIX D;
  304. {
  305.   char           *xs = c, *csave = c;
  306.   MINT   *m1,*m2,*m3,*m4;
  307.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  308.   else {
  309.     sprinta(A);
  310.     *c++ = '\0';
  311.   }
  312.   GET_MINT_ADDR(m1,xs);
  313.   if ( (int) m1 == -1)  return false;
  314.   c = csave;
  315.   if ((B->r == nil) && (B->l == nil)) xs = B->t;
  316.   else {
  317.     sprinta(B);
  318.     *c++ = '\0';
  319.   }
  320.   GET_MINT_ADDR(m2,xs);
  321.   if ( (int) m2 == -1)  return false;
  322.   c = csave;
  323.   if ((C->r == nil) && (C->l == nil)) xs = C->t;
  324.   else {
  325.     sprinta(C);
  326.     *c++ = '\0';
  327.   }
  328.   GET_MINT_ADDR(m3,xs);
  329.   if ( (int) m3 == -1)  return false;
  330.   c = csave;
  331.   m4 = itom(0);
  332.   pow (m1,m2,m3,m4);
  333.   D->t = c;
  334.   D->l = nil;
  335.   D->r = nil;
  336.   PUT_MINT_ADDR(m4);
  337.   return true;
  338. }
  339.  
  340.  
  341. /*  intisthegcdofintandint   */
  342. int dintisthegcdofintandint(C,A,B)
  343. register AFFIX C;
  344. register AFFIX A;
  345. register AFFIX B;
  346. {
  347.   char           *xs = c, *csave = c;
  348.   MINT   *m1,*m2,*m3;
  349.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  350.   else {
  351.     sprinta(A);
  352.     *c++ = '\0';
  353.   }
  354.   GET_MINT_ADDR(m1,xs);
  355.   if ( (int) m1 == -1)  return false;
  356.   c = csave;
  357.   if ((B->r == nil) && (B->l == nil)) xs = B->t;
  358.   else {
  359.     sprinta(B);
  360.     *c++ = '\0';
  361.   }
  362.   GET_MINT_ADDR(m2,xs);
  363.   if ( (int) m2 == -1)  return false;
  364.   c = csave;
  365.   m3 = itom(0);
  366.   gcd (m1,m2,m3);
  367.   C->t = c;
  368.   C->l = nil;
  369.   C->r = nil;
  370.   PUT_MINT_ADDR(m3);
  371.   return true;
  372.  
  373. }
  374.  
  375. /*  intisthesquarerootofintwithremainderint   */
  376. int dintisthesquarerootofintwithremainderint(C,A,B)
  377. register AFFIX C;
  378. register AFFIX A;
  379. register AFFIX B;
  380. {
  381.  
  382.   char           *xs = c, *csave = c;
  383.   MINT   *m1,*m2,*m3;
  384.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  385.   else {
  386.     sprinta(A);
  387.     *c++ = '\0';
  388.   }
  389.   GET_MINT_ADDR(m1,xs);
  390.   if ( (int) m1 == -1)  return false;
  391.   c = csave;
  392.   m2 = itom(0);
  393.   m3 = itom(0);
  394.   msqrt (m1,m2,m3);
  395.   B->t = c;
  396.   B->l = nil;
  397.   B->r = nil;
  398.   PUT_MINT_ADDR(m2);
  399.   C->t = c;
  400.   C->l = nil;
  401.   C->r = nil;
  402.   PUT_MINT_ADDR(m3);
  403.   return true;
  404.  
  405. }
  406.  
  407. int ddecisint(A,B)
  408. register AFFIX A, B;
  409. {
  410.    MINT *M ;
  411.    register char *xs =c, *csave =c;
  412.    if ((A->r == nil) && (A->l == nil)) xs = A->t;
  413.    else {
  414.       sprinta(A);
  415.       *c++ = '\0';
  416.    }
  417.    M = dectoint(xs);
  418.    c = csave;
  419.    B->t = c;
  420.    B->l = nil;
  421.    B->r = nil;
  422.    PUT_MINT_ADDR(M); 
  423.    return true;
  424. }
  425.  
  426. int dinitmint_(A,B)
  427. register AFFIX A, B;
  428. {
  429.    MINT *M ;
  430.    register char *xs =c, *csave =c;
  431.    if ((B->r == nil) && (B->l == nil)) xs = B->t;
  432.    else {
  433.       sprinta(B);
  434.       *c++ = '\0';
  435.    }
  436.    M = dectoint(xs);
  437.    c = csave;
  438.    A->t = c;
  439.    A->l = nil;
  440.    A->r = nil;
  441.    PUT_MINT_ADDR(M); 
  442.    return true;
  443. }
  444. /*  intisdec   */
  445. int dintisdec(A,B)
  446. register AFFIX A, B;
  447. {
  448.    register char           *xs = c, *rc =c;
  449.    MINT   *m1;
  450.    if ((A->r == nil) && (A->l == nil)) xs = A->t;
  451.    else {
  452.       sprinta(A);
  453.       *c++ = '\0';
  454.    }
  455.    B ->t = rc;
  456.    B ->r = nil;
  457.    B ->l = nil;
  458.    if (*xs == '\002') { 
  459.        MINT *cpy =  itom(0), *dmy = itom(0);
  460.        
  461.        GET_MINT_ADDR(m1,xs);
  462.        madd (m1,dmy,cpy);
  463.       inttodec(cpy);
  464.       mfree(cpy);
  465.       *c++ = '\0';
  466.       return true;
  467.    }
  468.    return false;
  469. }
  470.  
  471.  
  472. #define Base 10000
  473. inttodec(A)
  474. MINT *A;
  475. {
  476.    int len = A -> len;
  477.    short *val = A -> val;
  478.    MINT *R;
  479.    if (len < 0) {
  480.       len = -len;
  481.       A -> len = len;
  482.       *c++ = '-';
  483.    }
  484.    if (len == 1) {
  485.       register char * rc =c;
  486.       sprintf(rc,"%d",(int) *val);
  487.       while (*++rc !=  '\0') ;
  488.       c = rc;
  489.       return;
  490.    }
  491.    else if (len == 0) {
  492.       *c++ =  '0';
  493.       *c =  '\0';
  494.       return;
  495.    }
  496.    R = itom(0);
  497.    sdiv (A,Base,R,val);
  498.    inttodec(R);
  499.    mfree(R);
  500.    {
  501.       short v = *val;
  502.       register char * rc =c;
  503.       if (v < 1000)
  504.          *rc++ = '0';
  505.       if (v < 100)
  506.          *rc++ = '0';
  507.       if (v < 10)
  508.          *rc++ = '0';
  509.       sprintf(rc,"%d", (int) v);
  510.       while (*++rc !=  '\0') ;
  511.       c = rc;
  512.       return;
  513.    }
  514. }
  515.  
  516. static MINT * Mint_10, *R; 
  517.  
  518. int first_time_dec_to_mint =1;
  519.  
  520. MINT * dectoint (str)
  521. register  char *str;
  522. {
  523.   MINT * bignum;
  524.   int negate;
  525.   if (first_time_dec_to_mint) {
  526.       Mint_10 = itom(10);
  527.       R  = itom(0);
  528.       first_time_dec_to_mint =0;
  529.   }
  530.   if (str[0] == '-') {
  531.     str++;
  532.     negate = 1;
  533.  
  534.   } else {
  535.     negate = 0;
  536.   }
  537.  
  538.   bignum = itom(0);
  539.   while (*str) {
  540.     if (*str < '0' || *str > '9')
  541.       return bignum;
  542.     mult(Mint_10,bignum,R);
  543.     madd(R , itom(*str++ - '0'),bignum);
  544.   }
  545.   if (negate) bignum  -> len = - (bignum -> len);
  546.   return (bignum);
  547. }
  548.  
  549.  
  550. /*  freeint   */
  551. int dfreeint(A)
  552. register AFFIX A;
  553. {
  554.   register char *rc = c,  *xs = rc;
  555.   MINT   *m1;
  556.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  557.   else {
  558.     sprinta(A);
  559.     *c++ = '\0';
  560.   }
  561.   GET_MINT_ADDR(m1,xs);
  562.   if ( (int) m1 != -1)  mfree(m1);
  563.   c = rc;
  564.   A->t = rc;
  565.   A->l = nil;
  566.   A->r = nil;
  567.   PUT_MINT_ADDR(mzero);
  568.   return true; 
  569. }
  570.  
  571.  
  572. /*  decrementint   */
  573. int ddecrementsmallint(A)
  574. register AFFIX A;
  575. {
  576.   register char *rc = c,  *xs = rc;
  577.   MINT   *m1;
  578.   short *val;
  579.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  580.   else {
  581.     sprinta(A);
  582.     *c++ = '\0';
  583.   }
  584.   GET_MINT_ADDR(m1,xs);
  585.   if ( (int) m1 == -1)  return false;
  586.   
  587.   val = m1 -> val; 
  588.   if (m1 -> len  == 1)  {
  589.        if (*val == 0)  {
  590.             *val = 1;
  591.             m1 -> len = -1;
  592.        }
  593.        else  
  594.           *val -= 1; 
  595.   } else if (m1 -> len  == -1)  {
  596.           *val += 1; 
  597.   } else return false;
  598.   
  599.   c = rc;
  600.   return true; 
  601. }
  602.  
  603.    
  604. /*  incrementint   */
  605. int dincrementsmallint(A)
  606. register AFFIX A;
  607. {
  608.   register char *rc = c,  *xs = rc;
  609.   MINT   *m1;
  610.   short *val;
  611.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  612.   else {
  613.     sprinta(A);
  614.     *c++ = '\0';
  615.   }
  616.   GET_MINT_ADDR(m1,xs);
  617.   if ( (int) m1 == -1)  return false;
  618.  
  619.   val = m1 -> val; 
  620.   if (m1 -> len  == 1)  {
  621.        if (*val == 0)  {
  622.             *val = 1;
  623.             m1 -> len = 1;
  624.        }
  625.        else  
  626.           *val += 1; 
  627.   } else if (m1 -> len  == -1)  {
  628.        if (*val == 0)  {
  629.             *val = 1;
  630.             m1 -> len = 1;
  631.        }
  632.        else  
  633.           m1 -> val -= 1; 
  634.   } else return false;
  635.   
  636.   c = rc;
  637.   return true; 
  638. }
  639.  
  640.    
  641.  
  642. /*  smalldecisint   */
  643. int dsmalldecisint(A,B)
  644. register AFFIX A;
  645. register AFFIX B;
  646. {
  647.   register char *rc = c,  *xs = rc;
  648.   MINT   *m1;
  649.   int i;
  650.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  651.   else {
  652.     sprinta(A);
  653.     *c++ = '\0';
  654.   }
  655.   c = rc;
  656.   i = atoi(xs);
  657.   if (i > MAX_SHORT)
  658.         return false;
  659.   if  (i < MIN_SHORT) 
  660.         return false;
  661.   sprintf(c,"%d",i);
  662.   c += 6;
  663.   m1 = itom((short) i);
  664.   B -> t  = c;
  665.   B -> r = nil;
  666.   B -> l = nil;
  667.   PUT_MINT_ADDR(m1);
  668.   return true;
  669. }
  670.  
  671. /*  intisnegative   */
  672. int dintisnegative(A)
  673. register AFFIX A;
  674. {
  675.   register char *rc = c,  *xs = rc;
  676.   MINT   *m1;
  677.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  678.   else {
  679.     sprinta(A);
  680.     *c++ = '\0';
  681.   }
  682.   GET_MINT_ADDR(m1,xs);
  683.   if ( (int) m1 == -1)  return false;
  684.   c = rc;
  685.   return (m1->len <0);
  686. }
  687.  
  688.  
  689. /*  negateint   */
  690. int dnegateint(A)
  691. register AFFIX A;
  692. {
  693.   register char *rc = c,  *xs = rc;
  694.   MINT   *m1;
  695.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  696.   else {
  697.     sprinta(A);
  698.     *c++ = '\0';
  699.   }
  700.   GET_MINT_ADDR(m1,xs);
  701.   if ( (int) m1 == -1)  return false;
  702.   c = rc;
  703.   m1->len = -m1->len;
  704.   return true;
  705. }
  706.  
  707.  
  708.  
  709. /*  intispositive   */
  710. int dintispositive(A)
  711. register AFFIX A;
  712. {
  713.   register char *rc = c,  *xs = rc;
  714.   MINT   *m1;
  715.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  716.   else {
  717.     sprinta(A);
  718.     *c++ = '\0';
  719.   }
  720.   GET_MINT_ADDR(m1,xs);
  721.   if ( (int) m1 == -1)  return false;
  722.   c = rc;
  723.   return (m1->len >0);
  724. }
  725.  
  726.  
  727.  
  728. /*  intiszero   */
  729. int dintiszero(A)
  730. register AFFIX A;
  731. {
  732.   register char *rc = c,  *xs = rc;
  733.   MINT   *m1;
  734.   if ((A->r == nil) && (A->l == nil)) xs = A->t;
  735.   else {
  736.     sprinta(A);
  737.     *c++ = '\0';
  738.   }
  739.   GET_MINT_ADDR(m1,xs);
  740.   if ( (int) m1 == -1)  return false;
  741.   c = rc;
  742.   return (m1->len == 1 && *(m1->val) == 0);
  743. }
  744. #endif
  745.  
  746. #ifdef UMP
  747. void uintplusintisint () {
  748.    register cont *rq = q;
  749. register AFFIX C = (rq+0)-> a;
  750. register AFFIX B = (rq+-1)-> a;
  751. register AFFIX A = (rq+-2)-> a;
  752.    if (dintplusintisint(A,B,C))
  753.    {
  754.       q=rq+-4;
  755.       (*(rq+-3)->q)();
  756.       rq=q- -3;
  757.    }
  758.    (rq+-2)->a = A;
  759.    (rq+-1)->a = B;
  760.    (rq+0)->a = C;
  761.    (rq+1)-> q = uintplusintisint;
  762.    q = rq+1;
  763. }
  764.  
  765. void uintsubintisint () {
  766.    register cont *rq = q;
  767. register AFFIX C = (rq+0)-> a;
  768. register AFFIX B = (rq+-1)-> a;
  769. register AFFIX A = (rq+-2)-> a;
  770.    if (dintsubintisint(A,B,C))
  771.    {
  772.       q=rq+-4;
  773.       (*(rq+-3)->q)();
  774.       rq=q- -3;
  775.    }
  776.    (rq+-2)->a = A;
  777.    (rq+-1)->a = B;
  778.    (rq+0)->a = C;
  779.    (rq+1)-> q = uintsubintisint;
  780.    q = rq+1;
  781. }
  782.  
  783. void uinttimesintisint () {
  784.    register cont *rq = q;
  785. register AFFIX C = (rq+0)-> a;
  786. register AFFIX B = (rq+-1)-> a;
  787. register AFFIX A = (rq+-2)-> a;
  788.    if (dinttimesintisint(A,B,C))
  789.    {
  790.       q=rq+-4;
  791.       (*(rq+-3)->q)();
  792.       rq=q- -3;
  793.    }
  794.    (rq+-2)->a = A;
  795.    (rq+-1)->a = B;
  796.    (rq+0)->a = C;
  797.    (rq+1)-> q = uinttimesintisint;
  798.    q = rq+1;
  799. }
  800.  
  801. void uintdividedbyintisintwithremainderint () {
  802.    register cont *rq = q;
  803. register AFFIX D = (rq+0)-> a;
  804. register AFFIX C = (rq+-1)-> a;
  805. register AFFIX B = (rq+-2)-> a;
  806. register AFFIX A = (rq+-3)-> a;
  807.    if (dintdividedbyintisintwithremainderint(A,B,C,D))
  808.    {
  809.       q=rq+-5;
  810.       (*(rq+-4)->q)();
  811.       rq=q- -4;
  812.    }
  813.    (rq+-3)->a = A;
  814.    (rq+-2)->a = B;
  815.    (rq+-1)->a = C;
  816.    (rq+0)->a = D;
  817.    (rq+1)-> q = uintdividedbyintisintwithremainderint;
  818.    q = rq+1;
  819. }
  820.  
  821. void uintisint () {
  822.    register cont *rq = q;
  823. register AFFIX C = (rq+0)-> a;
  824. register AFFIX B = (rq+-1)-> a;
  825. register AFFIX A = (rq+-2)-> a;
  826.    if (dintisint(A,B,C))
  827.    {
  828.       q=rq+-4;
  829.       (*(rq+-3)->q)();
  830.       rq=q- -3;
  831.    }
  832.    (rq+-2)->a = A;
  833.    (rq+-1)->a = B;
  834.    (rq+0)->a = C;
  835.    (rq+1)-> q = uintisint;
  836.    q = rq+1;
  837. }
  838.  
  839. void uintraisedbyintmodulointisint () {
  840.    register cont *rq = q;
  841. register AFFIX D = (rq+0)-> a;
  842. register AFFIX C = (rq+-1)-> a;
  843. register AFFIX B = (rq+-2)-> a;
  844. register AFFIX A = (rq+-3)-> a;
  845.    if (dintraisedbyintmodulointisint(A,B,C,D))
  846.    {
  847.       q=rq+-5;
  848.       (*(rq+-4)->q)();
  849.       rq=q- -4;
  850.    }
  851.    (rq+-3)->a = A;
  852.    (rq+-2)->a = B;
  853.    (rq+-1)->a = C;
  854.    (rq+0)->a = D;
  855.    (rq+1)-> q = uintraisedbyintmodulointisint;
  856.    q = rq+1;
  857. }
  858.  
  859. void uintisthegcdofintandint () {
  860.    register cont *rq = q;
  861. register AFFIX C = (rq+0)-> a;
  862. register AFFIX B = (rq+-1)-> a;
  863. register AFFIX A = (rq+-2)-> a;
  864.    if (dintisthegcdofintandint(A,B,C))
  865.    {
  866.       q=rq+-4;
  867.       (*(rq+-3)->q)();
  868.       rq=q- -3;
  869.    }
  870.    (rq+-2)->a = A;
  871.    (rq+-1)->a = B;
  872.    (rq+0)->a = C;
  873.    (rq+1)-> q = uintisthegcdofintandint;
  874.    q = rq+1;
  875. }
  876.  
  877.  
  878. void uintisthesquarerootofintwithremainderint() {
  879.    register cont *rq = q;
  880. register AFFIX C = (rq+0)-> a;
  881. register AFFIX B = (rq+-1)-> a;
  882. register AFFIX A = (rq+-2)-> a;
  883.    if (dintisthesquarerootofintwithremainderint(A,B,C))
  884.    {
  885.       q=rq+-4;
  886.       (*(rq+-3)->q)();
  887.       rq=q- -3;
  888.    }
  889.    (rq+-2)->a = A;
  890.    (rq+-1)->a = B;
  891.    (rq+0)->a = C;
  892.    (rq+1)-> q = uintisthesquarerootofintwithremainderint;
  893.    q = rq+1;
  894. }
  895.  
  896. void udecisint () {
  897.    register cont *rq = q;
  898. register AFFIX B = (rq+0)-> a;
  899. register AFFIX A = (rq+-1)-> a;
  900.    if (ddecisint(A,B))
  901.    {
  902.       q=rq+-3;
  903.       (*(rq+-2)->q)();
  904.       rq=q- -2;
  905.    }
  906.    (rq+-1)->a = A;
  907.    (rq+0)->a = B;
  908.    (rq+1)-> q = udecisint;
  909.    q = rq+1;
  910. }
  911. void uintisdec () {
  912.    register cont *rq = q;
  913. register AFFIX B = (rq+0)-> a;
  914. register AFFIX A = (rq+-1)-> a;
  915.    if (dintisdec(A,B))
  916.    {
  917.       q=rq+-3;
  918.       (*(rq+-2)->q)();
  919.       rq=q- -2;
  920.    }
  921.    (rq+-1)->a = A;
  922.    (rq+0)->a = B;
  923.    (rq+1)-> q = uintisdec;
  924.    q = rq+1;
  925. }
  926.  
  927. void ufreeint () { 
  928.    register cont *rq = q;
  929. register AFFIX A = (rq+0)-> a;
  930.    if (dfreeint(A))
  931.    { 
  932.       q=rq+-2;
  933.       (*(rq+-1)->q)();
  934.       rq=q- -1;
  935.    }
  936.    (rq+0)->a = A;
  937.    (rq+1)-> q = ufreeint; 
  938.    q = rq+1; 
  939. }
  940.  
  941. void udecrementsmallint () { 
  942.    register cont *rq = q;
  943. register AFFIX A = (rq+0)-> a;
  944.    if (ddecrementsmallint(A))
  945.    { 
  946.       q=rq+-2;
  947.       (*(rq+-1)->q)();
  948.       rq=q- -1;
  949.    }
  950.    (rq+0)->a = A;
  951.    (rq+1)-> q = udecrementsmallint; 
  952.    q = rq+1; 
  953. }
  954.  
  955. void uincrementsmallint () { 
  956.    register cont *rq = q;
  957. register AFFIX A = (rq+0)-> a;
  958.    if (dincrementsmallint(A))
  959.    { 
  960.       q=rq+-2;
  961.       (*(rq+-1)->q)();
  962.       rq=q- -1;
  963.    }
  964.    (rq+0)->a = A;
  965.    (rq+1)-> q = uincrementsmallint; 
  966.    q = rq+1; 
  967. }
  968.  
  969. void usmalldecisint () { 
  970.    register cont *rq = q;
  971. register AFFIX B = (rq+0)-> a;
  972. register AFFIX A = (rq+-1)-> a;
  973.    if (dsmalldecisint(A,B))
  974.    { 
  975.       q=rq+-3;
  976.       (*(rq+-2)->q)();
  977.       rq=q- -2;
  978.    }
  979.    (rq+-1)->a = A;
  980.    (rq+0)->a = B;
  981.    (rq+1)-> q = usmalldecisint; 
  982.    q = rq+1; 
  983. }
  984.  
  985. void uintisnegative () { 
  986.    register cont *rq = q;
  987. register AFFIX A = (rq+0)-> a;
  988.    if (dintisnegative(A))
  989.    { 
  990.       q=rq+-2;
  991.       (*(rq+-1)->q)();
  992.       rq=q- -1;
  993.    }
  994.    (rq+0)->a = A;
  995.    (rq+1)-> q = uintisnegative; 
  996.    q = rq+1; 
  997. }
  998.  
  999. void unegateint () { 
  1000.    register cont *rq = q;
  1001. register AFFIX A = (rq+0)-> a;
  1002.    if (dnegateint(A))
  1003.    { 
  1004.       q=rq+-2;
  1005.       (*(rq+-1)->q)();
  1006.       rq=q- -1;
  1007.    }
  1008.    (rq+0)->a = A;
  1009.    (rq+1)-> q = unegateint; 
  1010.    q = rq+1; 
  1011. }
  1012.  
  1013. void uintispositive () { 
  1014.    register cont *rq = q;
  1015. register AFFIX A = (rq+0)-> a;
  1016.    if (dintispositive(A))
  1017.    { 
  1018.       q=rq+-2;
  1019.       (*(rq+-1)->q)();
  1020.       rq=q- -1;
  1021.    }
  1022.    (rq+0)->a = A;
  1023.    (rq+1)-> q = uintispositive; 
  1024.    q = rq+1; 
  1025. }
  1026.  
  1027. void uintiszero () { 
  1028.    register cont *rq = q;
  1029. register AFFIX A = (rq+0)-> a;
  1030.    if (dintiszero(A))
  1031.    { 
  1032.       q=rq+-2;
  1033.       (*(rq+-1)->q)();
  1034.       rq=q- -1;
  1035.    }
  1036.    (rq+0)->a = A;
  1037.    (rq+1)-> q = uintiszero; 
  1038.    q = rq+1; 
  1039. }
  1040. #endif
  1041.